Numerical operations with Numpy¶

3.1 Broadcasting¶

3.2 Array shape manipulation¶

3.3 Sorting data¶

Summary¶

Exercises¶

3.1 Broadcasting Operations¶

• We just covered basic operations (add, multiple, square etc) such are element-wise but that works on arrays of same size

• Broadcasting comes handy when we are dealing with different shapes. This time, we'll explore a more advanced concept in numpy called broadcasting.

• The term broadcasting describes how numpy treats arrays with different shapes during arithmetic operations. Subject to certain constraints, the smaller array is "broadcast" across the larger array so that they have compatible shapes.

• Broadcasting provides a means of vectorizing array operations so that looping occurs in C instead of Python. It does this without making needless copies of data and usually leads to efficient algorithm implementations. There are also cases where broadcasting is a bad idea because it leads to inefficient use of memory that slows computation.

• In this little tutorial we will provide a gentle introduction to broadcasting with numerous examples ranging from simple to involved.

• We will also go through a few examples of when to and when not to use boradcasting.

This example below shows how broadcasting works¶

So, lets start taking baby steps...¶

Here an element-wise multiplication occurs since the two arrays are of same shape

Hint / Try it?¶

What would have happened if f = np.array([2.0, 2.0]). would it still multiply?

What happened here¶

This is the most simplest example on numpy broadcasting where an array and a scalar values were combined in an operation.

so it kind of stechted in the row direction! The scalar f is stretched to become an array of with the same shape as e so the shapes are compatible for element-by-element multiplication.

** So what are the rules then?**

• They must either be equal / same shape

OR

• One of them must be 1, like f was above

What happened above?¶

A 2-D (two-dimensional) array multiplied by 1-D (one-dimensional) array. It got stretched in the column direction so as to match the elements of the 2D array columns.

Would the same be possible for different shapes? Does broadcasting magically understands and fixes our assumptions?

Let's take a look...

We had a mismatch...¶

Explanation: When the trainling dimensions of the arrays are different as you saw above, then broadcasting will fail making it impossible to align the values in the rows of the first array with the elements of the second array for an element-by-element addition or multiplication.

Also, is there a way to do this in one line of code¶

Tip: look up more into np.tile and np.arange

Now, we add these two¶

So you see that broadcasting was applied magically...¶

Ask yourself, why couldn't we add original a and b ?

Note, original a was:

array([[0,10,20,30],[0,10,20,30],[0,10,20,30]])

Let's assign an array of dimension 0 to an array of dimension 1¶

Another example on broadcasting¶

Let’s construct an array of distances (in miles) between cities of Route 66: Chicago, Springfield, Saint-Louis, Tulsa, Oklahoma City, Amarillo, Santa Fe, Albuquerque, Flagstaff and Los Angeles.

Another example¶

A lot of grid-based or network-based problems can also use broadcasting. For instance, if we want to compute the distance from the origin of points on a 10x10 grid, we can do

Or in color...¶

np.ogrid is quite useful as soon as we have to handle computations on a grid. While on other hand, np.mgrid directly provides matrices full of indices for cases where we can't or maybe don't want to benefit from broadcasting.

A bit on Vector quantization or VQ¶

A simple way to understand bradcasting is with this real world situation. The basic operatio in VQ finds the closest point in a set of points, called $codes$ in VQ speak, to a given point, called the observation.

In the 2D example below, the value in an $observation$ describe the weight and height of an athlete to be classified. The $codes$ represent different classes of athletes such as dancer, runner, swimmer an so on.

Finding the closest point requires calculating the distance between observation and each of the codes.

The shortest distance provides the best match. Here in this example, codes[0] is the closest class indicating that the athlete is likely a basketball player.

The basic operation of vector quantization calculates the distance between an object to be classified, the black square, and multiple known codes, the gray circles. In the very basic case, the codes represent classes.

A more advanced example¶

@article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011} }

3.2 Array Shape Manipulation¶

Flattening¶

Reshaping¶

Memory layout of a numpy array¶

• Here's a good example of how it works

3.3 Sorting Data¶

Function

sort (arr, axis=-1, kind='quick', order=None)

Method

arr.sort (axis=-1, kind='quick', order=None)

Some Exercises 😅¶

1. Array manipulations¶

Create this 2D array (without typing manually)

[[1, 7, 12], [2, 8, 13], [3, 9, 14], [4, 10, 15], [5, 11, 16]]

2.¶

Fun Exercises: Challenge questions¶

1. Try in-place, out_of_place sorting
2. Create arrays with different dtypes and sort them.
3. Use all or array_equal to see what it returns
4. Use np.random.shuffle to create a more sortable input
5. Combine ravel, sort and reshape in one
6. Look at the axis keyword for sort and rewrite the previous exercise